#!/usr/bin/env python3
# -*- coding: utf-8 -*-

'''
@Author : JoeyGosson
@Time   : 2019/10/08 14:40
@File   : resource_manager.py
'''
import os, sys, requests
sys.path.append(os.path.abspath(os.path.dirname(os.path.dirname(__file__))))
from DBUtils.PooledDB import PooledDB
from pymysql.cursors import DictCursor
from config.settings import *
import pymysql, redis


class Resource_manager(object):
    def __init__(self, redis_flag=False, mysql_flag=False, mongo_flag=False, redis_proxy_pool_flag=False, redis_db=REDIS_DB, proxy_redis_db=PROXY_REDIS_DB):
        '''
        初始化
        :param redis_flag: redis连接池开关
        :param mysql_flag: mongo连接池开关
        :param mongo_flag: mysql连接池开关
        :param redis_proxy_pool_flag: redis代理池连接池开关
        :return: None
        '''
        self.__mysql_flag = mysql_flag
        self.__mongo_flag = mongo_flag
        self.__redis_flag = redis_flag
        self.__redis_proxy_pool_flag = redis_proxy_pool_flag

        if self.__mysql_flag: # mysql连接池初始化
            self.mysql_conn_pool = {}
            for cfg in MYSQL_CONFIG:
                self.mysql_conn_pool[cfg["name"]] = PooledDB(
                    creator= pymysql,
                    mincached= cfg["mincached"],
                    maxcached= cfg["maxcached"],
                    host= cfg["host"],
                    port= cfg["port"],
                    user= cfg["user"],
                    passwd= cfg["password"],
                    db= cfg["db"],
                    use_unicode= cfg["use_unicode"],
                    charset= cfg["charset"],
                    cursorclass= DictCursor,
                )


        if self.__redis_flag: # redis连接池初始化
            redis_conn_pool = redis.ConnectionPool(host=REDIS_HOST, port=REDIS_PORT, db=redis_db,
                                                   password=REDIS_PASSWOLRD, decode_responses=REDIS_DECODE,
                                                   max_connections=REDIS_MAX_CONNECTION)
            self.redis_helper = redis.Redis(connection_pool=redis_conn_pool)


        if self.__redis_proxy_pool_flag:  # redis代理池连接池初始化
            redis_conn_pool = redis.ConnectionPool(host=PROXY_REDIS_HOST, port=PROXY_REDIS_PORT, db=proxy_redis_db,
                                                   password=PROXY_REDIS_PASSWOLRD, decode_responses=PROXY_REDIS_DECODE,
                                                   max_connections=REDIS_MAX_CONNECTION)
            self.redis_helper = redis.Redis(connection_pool=redis_conn_pool)


    def mysql_connection(self, name):
        '''
        获取连接池对象
        :return: 连接池对象
        '''
        if self.mysql_conn_pool[name]:
            return self.mysql_conn_pool[name].connection()
        return None

    def mysql_release_connection(self, conn):
        '''
        关闭连接连接对象
        :param conn: 连接对象
        :return: None
        '''
        if conn:
            conn.close()


    def redis_return_helper(self):
        '''
        从redis连接池中获取一个连接对象
        此对象使用完成后会自动回收
        '''
        if self.__redis_flag:
            return self.redis_helper
        if self.__redis_proxy_pool_flag:
            return self.redis_helper
        return None

    def redis_return_pipeline(self, tr=True):
        '''
        管道（pipeline）是redis在提供单个请求中缓冲多条服务器命令的基类的子类。
        它通过减少服务器-客户端之间反复的TCP数据库包，从而大大提高了执行批量命令的功能。

        线上的redis一般都是集群模式，集群模式下使用pipeline的时候，在创建pipeline的对象时，需要指定tr=False
        '''
        if self.__redis_flag:
            if tr:
                return self.redis_return_helper().pipeline(transaction=tr)
            return self.redis_return_helper().pipeline(transaction=tr)
        if self.__redis_proxy_pool_flag:
            if tr:
                return self.redis_return_helper().pipeline(transaction=tr)
            return self.redis_return_helper().pipeline(transaction=tr)
        return None


